<?php

/*
 * Translated from YUILoader.js version 2.7.0
 */
class YUILoader {

	private static $dupsAllowed = array('yahoo' => true, 'get' => true);
	private static $data = null;
	private static $insertBefore = null;
	private static $charset = null;
	private static $varName = null;
	//private static $base = defined('YUI_BASE') ? constant('YUI_BASE') : '/yui/';
	private static $combine = false;
	private static $ignore = null;
	private static $force = null;
	private static $allowRollup = true;
	private static $filter = null;
	private static $required = array();

	private static $rollups = null;
	private static $loadOptional = false;
	private static $sorted = array();
	private static $loaded = array();
	public static $dirty = true;

	public static $FILTERS = array(
		'RAW' => array(
			'searchExp' => "-min.js",
			'replaceStr' => ".js"
		),
		'DEBUG' => array(
			'searchExp' => "-min.js",
			'replaceStr' => "-debug.js"
		),
		'BETA' => array(
			'searchExp' => "-min.js",
			'replaceStr' => "-beta-min.js"
		),
		'EXPERIMENTAL' => array(
			'searchExp' => "-min.js",
			'replaceStr' => "-experimental-min.js"
		)
	);

	public static $SKIN_PREFIX = "skin-";

	public static function _js() {
		if (self::$dirty) {
			self::calculate();
		}

		$js = array();
		$s =& self::$sorted;
		$ver = !(defined('TIMESTAMP_INCLUDED') ? constant('TIMESTAMP_INCLUDED') : false);

		foreach ($s as $m) {
			if($m) {
				$js[] = self::_url($m);
			}
		}
		return $js;
	}

	public static function _dump() {
		if(!self::$sorted) {
			echo implode(array_keys(self::$required), ", ");
		} else {
			echo implode(array_values(self::$sorted), ", ");
		}
		echo "\n\n";
	}

	public static function _isYUIModule($path) {
		$m = array();
		preg_match('/\/([a-z-]*)\/\1(?:-experimental|-beta)?(?:-min)?.js/', $path, &$m);
		if (isset($m[1]) && isset(self::$moduleInfo[$m[1]])) {
			return $m[1];
		} else {
			return false;
		}
	}

	public static function _config($o = null) {

		// apply config values
		if ($o) {
			foreach ($o as $i) {
				if ($i == "require") {
					self::_require($o[$i]);
				} else {
					self::$$i = $o[$i];
				}
			}
		}

		// fix filter
		$f = self::$filter;

		if (is_string($f)) {
			$f = strtoupper($f);

			// the logger must be available in order to use the debug
			// versions of the library
			if ($f === "DEBUG") {
				self::_require("logger");
			}

			self::$filter = self::$FILTERS[$f];
		}
	}

	public static function addModule($o = null) {

		if (is_null($o) || !isset($o['name']) || !isset($o['type']) || (!isset($o['path']) && !isset($o['fullpath']))) {
			return false;
		}

		$o['ext'] = isset($o['ext']) ? $o['ext'] : true;
		if (!isset($o['requires']) || !is_array($o['requires'])) {
			$o['requires'] = array();
		}

		self::$moduleInfo[$o['name']] = $o;
		self::$dirty = true;

		return true;
	}

	public static function _appendArray(&$o, $a) {
		if (is_array($a)) {
			for ($i=0; $i<count($a); ++$i) {
				$o[$a[$i]] = true;
			}
		}
	}
	public static function _require($what) {
		$a = is_string($what) ? func_get_args() : $what;
		self::$dirty = true;
		self::_appendArray(self::$required, $a);
	}

	public static function getRequires(&$mod) {
		if (!$mod) {
			return array();
		}

		if (!self::$dirty && $mod['expanded']) {
			return $mod['expanded'];
		}

		if (!isset($mod['requires'])) {
			$mod['requires'] = array();
		}

		$d = array();
		$r = $mod['requires'];
		$o = $mod['optional'];
		$info =& self::$moduleInfo;

		for ($i=0; $i<count($r); ++$i) {
			$d[] = $r[$i];
			$m = $info[$r[$i]];
			$d = array_merge($d, self::getRequires($m));
		}

		if ($o && self::$loadOptional) {
			for ($i=0; $i<count($o); ++$i) {
				$d[] = $o[$i];
				$d = array_merge($d, self::getReqires($info[$o[$i]]));
			}
		}

		$mod['expanded'] = array_unique($d);

		return $mod['expanded'];
	}

	public static function getProvides($name, $notMe) {
		$addMe = !$notMe;
		$ckey = $addMe ? "_provides" : "_supersedes";
		$m = self::$moduleInfo[$name];
		$o = array();

		if (!$m) {
			return $o;
		}

		if ($m[$ckey]) {
			return $m[$ckey];
		}

		$s = $m['supersedes'];
		$done = array();

		// calculate superseded modules
		if ($s) {
			for ($i=0; $i<count($s); ++$i) {
				if (!$done($s[$i])) {
					$done[$s[$i]] = true;
				}
			}
		}

		// supersedes cache
		$m["_supersedes"] = $o;
		// provides cache
		$m["_provides"] = $o;
		$m["_provides"][$name] = true;

		return $m[$ckey];
	}

	public static function calculate($o = null) {
		if ($o || self::$dirty) {
			self::_config($o);
			//self::_setup();
			self::_explode();
			if (self::$allowRollup) {
				self::_rollup();
			}
			self::_reduce();
			self::_sort();

			self::$dirty = false;
		}
	}

	public static function _setup() {
		$info = self::$moduleInfo;

		$l = clone self::$inserted;

		if (!self::$sandbox) {
			//$l = array_merge($l, $env['modules']);
		}

		// add the ignore list to the list of loaded packages
		if (self::$ignore) {
			self::_appendArray($l, self::$ignore);
		}

		// remove modules on the force list from the loaded list
		if (self::$force) {
			for ($i=0; $i<count(self::$force); ++$i) {
				if (isset($l[self::$force[$i]])) {
					unset($l[self::$force[$i]]);
				}
			}
		}

		// expand the list to include superseded modules
		foreach ($l as $j) {
			$l = array_merge($l, self::getProvides($j));
		}

		self::$loaded = $l;
	}

	public static function _explode() {
		$r =& self::$required;

		foreach ($r as $i => $x) {
			if (isset(self::$moduleInfo[$i])) {
				$mod =& self::$moduleInfo[$i];
				$req = self::getRequires($mod);

				if ($req) {
					self::_appendArray($r, $req);
				}
			}
		}
	}

	public static function formatSkin($skin, $mod) {
		$s = self::$SKIN_PREFIX + $skin;
		if ($mod) {
			$s += "-" . $mod;
		}
		return $s;
	}

	public static function parseSkin($mod) {
		if (strpos($mod, self::$SKIN_PREFIX)) {
			$a = explode('-', $mod);
			return array('skin' => $a[1], 'module' => $a[2]);
		}
		return null;
	}

	public static function _rollup() {
		$rollups = array();
		$r =& self::$required;
		$info =& self::$moduleInfo;

		// find and cache rollup modules
		if (self::$dirty || !self::$rollups) {
			foreach ($info as $i => $m) {
				if (isset($m['rollup'])) {
					$rollups[$i] = $m;
				}
			}

			self::$rollups = $rollups;
		}

		// make as many passes as needed to pick up rollup rollups
		while (true) {
			$rolled = false;

			// go through the rollup candidates
			foreach ($rollups as $i => $m) {

				// there can be only one
				if (!isset($r[$i])) {
					$s = $m['supersedes'];
					$roll = false;

					if (!isset($m['rollup'])) {
						continue;
					}

					$skin = $m['ext'] ? false : self::parseSkin($i);
					$c = 0;

					if ($skin) {
						foreach ($r as $j) {
							if ($i != $j && self::parseSkin($j)) {
								$roll = (++$c >= $m['rollup']);
								if ($roll) {
									break;
								}
							}
						}
					} else {
						// check the threshold
						for ($j=0;$j<count($s);++$j) {
							// if the superseded module is loaded, we can't load the rollup
							if (isset(self::$loaded[$s[$j]]) && !isset(self::$dupsAllowed[$s[$j]])) {
								$roll = false;
								break;
								// increment the counter if this module is required.  if we are
								// beyond the rollup threshold, we will use the rollup module
							} else if (isset($r[$s[$j]])) {
								$roll = (++$c >= $m['rollup']);
								if ($roll) {
									break;
								}
							}
						}
					}

					if ($roll) {
						$r[$i] = true;

						$rolled = true;

						// expand the rollup's dependencies
						self::getRequires($m);
					}
				}
			}

			// if we made it here w/o rolling up something, we are done
			if (!$rolled) {
				break;
			}
		}
	}

	public static function _reduce() {
		$r =& self::$required;
		foreach ($r as $i => $x) {
			// remove if already loaded
			if (isset(self::$loaded[$i])) {
				unset($r[$i]);

				// remove anything this module supersedes
			} else {

				$skinDef = self::parseSkin($i);

				if ($skinDef) {
					// the skin rollup will not have a module name
					if (!isset($skinDef['module'])) {
						$skin_pre = self::$SKIN_PREFIX . $skinDef['skin'];
						foreach ($r as $j) {
							$m = self::$moduleInfo[$j];
							$ext = isset($m['ext']) && $m['ext'];
							if (!$ext && $j != $i && strpos($j, $skin_pre) !== false) {
								unset($r[$j]);
							}
						}
					}
				} else {
					$s = self::$moduleInfo[$i]['supersedes'];
					if ($s) {
						for ($j=0; $j<count($s); ++$j) {
							if (isset($r[$s[$j]])) {
								unset($r[$s[$j]]);
							}
						}
					}
				}
			}
		}
	}

	private static function _sort_requires($aa, $bb) {
		$mm = self::$moduleInfo[$aa];

		if (isset(self::$loaded[$bb]) || is_null($mm)) {
			return false;
		}

		$rr = $mm['expanded'];
		$after = $mm['after'];
		$other = self::$moduleInfo[$bb];
		$optional = $mm['optional'];

		// check if this module requires the other directly
		if ($rr && in_array($bb, $rr)) {
			return true;
		}
		// check if this module should be sorted after the other
		if ($after && in_array($bb, $after)) {
			return true;
		}

		// if loadOptional is not specified, optional dependencies still
		// must be sorted correctly when present.
		if (!self::$loadOptional && $optional && in_array($bb, $optional)) {
			return true;
		}

		// check if this module requires one the other supersedes
		$ss = self::$moduleInfo[$bb]['supersedes'];
		if ($ss) {
			for ($ii=0; $ii<count($ss); ++$ii) {
				if (self::_sort_requires($aa, $ss[$ii])) {
					return true;
				}
			}
		}

		// external css files should be sorted below yui css
		if ($mm['ext'] && $mm['type'] == 'css' && !$other['ext'] && $other['type'] == 'css') {
			return true;
		}

		return false;
	}

	public static function _sort() {
		// create an indexed list
		$s = array();
		$info = self::$moduleInfo;
		$loaded = self::$loaded;
		$checkOptional = !self::$loadOptional;

		// returns true if b is not loaded, and is required
		// directly or by means of modules it supersedes.

		// get the required items out of the obj into an array so we
		// can sort
		$s = array_keys(self::$required);

		// pointer to the first unsorted item
		$p = 0;

		// keep going until we make a pass without moving anything
		while (true) {

			$l = count($s);
			$moved = false;

			// start the loop after items that are already sorted
			for ($j=$p; $j<$l; ++$j) {

				// check the next module on the list to see if its
				// dependencies have been met
				$a = $s[$j];

				// check everything below current item and move if we
				// find a requirement for the current item
				for ($k=$j+1; $k<$l; ++$k) {
					if (self::_sort_requires($a, $s[$k])) {

						// extract the dependency so we can move it up
						$b = array_splice($s, $k, 1);

						// insert the dependency above the item that 
						// requires it
						array_splice(&$s, $j, 0, $b[0]);

						$moved = true;
						break;
					}
				}

				// jump out of loop if we moved something
				if ($moved) {
					break;
					// this item is sorted, move our pointer and keep going
				} else {
					++$p;
				}
			}

			// when we make it here and moved is false, we are 
			// finished sorting
			if (!$moved) {
				break;
			}

		}

		self::$sorted = $s;
	}

	public static function _filter($filter, $str) {
		$f = !is_null($filter) ? self::$FILTERS[$filter] : null;
		return !is_null($f) ? str_replace($f['searchExp'], $f['replaceStr'], $str) : $str;
	}

	public static function _url($module, $include_version = true) {
		$base = defined('YUI_BASE') ? constant('YUI_BASE') : '/yui/build/';
		$m = self::$moduleInfo[$module];
		$filter = null;
		if (isset($m['beta'])) {
			$filter = 'BETA';
		} else if (isset($m['experimental'])) {
			$filter = 'EXPERIMENTAL';
		}
		$path = $base . '/' . $m['path'] . ($include_version && isset($m['version']) ? "?v=" . $m['version'] : '');
		return self::_filter($filter, $path);
	}

	public static function _verifyModuleInfo() {
		$yui_base = '/www/static/yui/build/';

		foreach(YUILoader::$moduleInfo as $key => $val) {
			$path = $yui_base . $val['path'];
			$beta = str_replace('-min','-beta-min', $path);
			$exp = str_replace('-min','-experimental-min', $path);

			if(file_exists($path)) {
				if(isset($val['beta']) || isset($val['experimental']) || isset($val['missing'])) {
					echo $key, " is gold\n";
				}
				if($val['version'] !== ($ver = self::_getVersion($path))) {
					echo $key, " is version $ver\n";
				}
			} else if(file_exists($beta)) {
				if($val['beta'] !== true) {
					echo $key, " is beta\n";
				}
				if($val['version'] !== ($ver = self::_getVersion($beta))) {
					echo $key, " is version $ver\n";
				}
			} else if(file_exists($exp)) {
				if($val['experimental'] !== true) {
					echo $key, " is experimental\n";
				}
				if($val['version'] !== ($ver = self::_getVersion($exp))) {
					echo $key, " is version $ver\n";
				}
			} else {
				if($val['missing'] !== true) {
					echo $key, " is missing\n";
				}
			}
		}
	}

	public static function _getVersion($path) {
		$data = file_get_contents($path);
		$m = array();
		preg_match('/version: (.*)$/m',$data, &$m);
		return $m[1];
	}

	public static $moduleInfo = array(
		'animation' => array(
			'type' => 'js',
			'path' => 'animation/animation-min.js',
			'requires' => array('dom', 'event'),
			'version' => '2.5.1'
		),
		'autocomplete' => array(
			'type' => 'js',
			'path' => 'autocomplete/autocomplete-min.js',
			'requires' => array('dom', 'event', 'datasource'),
			'optional' => array('connection', 'animation'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'base' => array(
			'type' => 'css',
			'path' => 'base/base-min.css',
			'after' => array('reset', 'fonts', 'grids'),
			'version' => '2.5.1'
		),
		'button' => array(
			'type' => 'js',
			'path' => 'button/button-min.js',
			'requires' => array('element'),
			'optional' => array('menu'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'calendar' => array(
			'type' => 'js',
			'path' => 'calendar/calendar-min.js',
			'requires' => array('event', 'dom'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'carousel' => array(
			'type' => 'js',
			'path' => 'carousel/carousel-min.js',
			'requires' => array('element'),
			'optional' => array('animation'),
			'skinnable' => true,
			'missing' => true
		),
		'charts' => array(
			'type' => 'js',
			'path' => 'charts/charts-min.js',
			'requires' => array('element', 'json', 'datasource'),
			'experimental' => true,
			'version' => '2.5.1'
		),
		'colorpicker' => array(
			'type' => 'js',
			'path' => 'colorpicker/colorpicker-min.js',
			'requires' => array('slider', 'element'),
			'optional' => array('animation'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'connection' => array(
			'type' => 'js',
			'path' => 'connection/connection-min.js',
			'requires' => array('event'),
			'version' => '2.5.1'
		),
		'container' => array(
			'type' => 'js',
			'path' => 'container/container-min.js',
			'requires' => array('dom', 'event'),
			// button is also optional, but this creates a circular
			// dependency when loadOptional is specified. button
			// optionally includes menu, menu requires container.
			'optional' => array('dragdrop', 'animation', 'connection'),
			'supersedes' => array('containercore'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'containercore' => array(
			'type' => 'js',
			'path' => 'container/container_core-min.js',
			'requires' => array('dom', 'event'),
			'pkg' => 'container',
			'version' => '2.5.1'
		),
		'cookie' => array(
			'type' => 'js',
			'path' => 'cookie/cookie-min.js',
			'requires' => array('yahoo'),
			'beta' => true,
			'version' => '2.5.1'
		),
		'datasource' => array(
			'type' => 'js',
			'path' => 'datasource/datasource-min.js',
			'requires' => array('event'),
			'optional' => array('connection'),
			'beta' => true,
			'version' => '2.5.1'
		),
		'datatable' => array(
			'type' => 'js',
			'path' => 'datatable/datatable-min.js',
			'requires' => array('element', 'datasource'),
			'optional' => array('calendar', 'dragdrop', 'paginator'),
			'skinnable' => true,
			'beta' => true,
			'version' => '2.5.1'
		),
		'dom' => array(
			'type' => 'js',
			'path' => 'dom/dom-min.js',
			'requires' => array('yahoo'),
			'version' => '2.5.1'
		),
		'dragdrop' => array(
			'type' => 'js',
			'path' => 'dragdrop/dragdrop-min.js',
			'requires' => array('dom', 'event'),
			'version' => '2.5.1'
		),
		'editor' => array(
			'type' => 'js',
			'path' => 'editor/editor-min.js',
			'requires' => array('menu', 'element', 'button'),
			'optional' => array('animation', 'dragdrop'),
			'supersedes' => array('simpleeditor'),
			'skinnable' => true,
			'beta' => true,
			'version' => '2.5.1'
		),
		'element' => array(
			'type' => 'js',
			'path' => 'element/element-min.js',
			'requires' => array('dom', 'event'),
			'beta' => true,
			'version' => '2.5.1'
		),
		'event' => array(
			'type' => 'js',
			'path' => 'event/event-min.js',
			'requires' => array('yahoo'),
			'version' => '2.5.1'
		),
		'fonts' => array(
			'type' => 'css',
			'path' => 'fonts/fonts-min.css',
			'version' => '2.5.1'
		),
		'get' => array(
			'type' => 'js',
			'path' => 'get/get-min.js',
			'requires' => array('yahoo'),
			'version' => '2.5.1'
		),
		'grids' => array(
			'type' => 'css',
			'path' => 'grids/grids-min.css',
			'requires' => array('fonts'),
			'optional' => array('reset'),
			'version' => '2.5.1'
		),
		'history' => array(
			'type' => 'js',
			'path' => 'history/history-min.js',
			'requires' => array('event'),
			'version' => '2.5.1'
		),
		'imagecropper' => array(
			'type' => 'js',
			'path' => 'imagecropper/imagecropper-min.js',
			'requires' => array('dom', 'event', 'dragdrop', 'element', 'resize'),
			'skinnable' => true,
			'beta' => true,
			'version' => '2.5.1'
		),
		'imageloader' => array(
			'type' => 'js',
			'path' => 'imageloader/imageloader-min.js',
			'requires' => array('event', 'dom'),
			'version' => '2.5.1'
		),
		'json' => array(
			'type' => 'js',
			'path' => 'json/json-min.js',
			'requires' => array('yahoo'),
			'version' => '2.5.1'
		),
		'layout' => array(
			'type' => 'js',
			'path' => 'layout/layout-min.js',
			'requires' => array('dom', 'event', 'element'),
			'optional' => array('animation', 'dragdrop', 'resize', 'selector'),
			'skinnable' => true,
			'beta' => true,
			'version' => '2.5.1'
		),
		'logger' => array(
			'type' => 'js',
			'path' => 'logger/logger-min.js',
			'requires' => array('event', 'dom'),
			'optional' => array('dragdrop'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'menu' => array(
			'type' => 'js',
			'path' => 'menu/menu-min.js',
			'requires' => array('containercore'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'paginator' => array(
			'type' => 'js',
			'path' => 'paginator/paginator-min.js',
			'requires' => array('element'),
			'skinnable' => true,
			'missing' => true
		),
		'profiler' => array(
			'type' => 'js',
			'path' => 'profiler/profiler-min.js',
			'requires' => array('yahoo'),
			'beta' => true,
			'version' => '2.5.1'
		),
		'profilerviewer' => array(
			'type' => 'js',
			'path' => 'profilerviewer/profilerviewer-min.js',
			'requires' => array('profiler', 'yuiloader', 'element'),
			'skinnable' => true,
			'beta' => true,
			'version' => '2.5.1'
		),
		'reset' => array(
			'type' => 'css',
			'path' => 'reset/reset-min.css',
			'version' => '2.5.1'
		),
		'reset-fonts-grids' => array(
			'type' => 'css',
			'path' => 'reset-fonts-grids/reset-fonts-grids.css',
			'supersedes' => array('reset', 'fonts', 'grids', 'reset-fonts'),
			'rollup' => 4,
			'version' => '2.5.1'
		),
		'reset-fonts' => array(
			'type' => 'css',
			'path' => 'reset-fonts/reset-fonts.css',
			'supersedes' => array('reset', 'fonts'),
			'rollup' => 2,
			'version' => '2.5.1'
		),
		'resize' => array(
			'type' => 'js',
			'path' => 'resize/resize-min.js',
			'requires' => array('dom', 'event', 'dragdrop', 'element'),
			'optional' => array('animation'),
			'skinnable' => true,
			'beta' => true,
			'version' => '2.5.1'
		),
		'selector' => array(
			'type' => 'js',
			'path' => 'selector/selector-min.js',
			'requires' => array('yahoo', 'dom'),
			'beta' => true,
			'version' => '2.5.1'
		),
		'simpleeditor' => array(
			'type' => 'js',
			'path' => 'editor/simpleeditor-min.js',
			'requires' => array('element'),
			'optional' => array('containercore', 'menu', 'button', 'animation', 'dragdrop'),
			'skinnable' => true,
			'pkg' => 'editor',
			'beta' => true,
			'version' => '2.5.1'
		),
		'slider' => array(
			'type' => 'js',
			'path' => 'slider/slider-min.js',
			'requires' => array('dragdrop'),
			'optional' => array('animation'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'stylesheet' => array(
			'type' => 'js',
			'path' => 'stylesheet/stylesheet-min.js',
			'requires' => array('yahoo'),
			'missing' => true
		),
		'tabview' => array(
			'type' => 'js',
			'path' => 'tabview/tabview-min.js',
			'requires' => array('element'),
			'optional' => array('connection'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'treeview' => array(
			'type' => 'js',
			'path' => 'treeview/treeview-min.js',
			'requires' => array('event', 'dom'),
			'optional' => array('json'),
			'skinnable' => true,
			'version' => '2.5.1'
		),
		'uploader' => array(
			'type' => 'js',
			'path' => 'uploader/uploader.js',
			'requires' => array('element'),
			'missing' => true
		),
		'utilities' => array(
			'type' => 'js',
			'path' => 'utilities/utilities.js',
			'supersedes' => array('yahoo', 'event', 'dragdrop', 'animation', 'dom', 'connection', 'element', 'yahoo-dom-event', 'get', 'yuiloader', 'yuiloader-dom-event'),
			'rollup' => 8,
			'version' => '2.5.1'
		),
		'yahoo' => array(
			'type' => 'js',
			'path' => 'yahoo/yahoo-min.js',
			'version' => '2.5.1'
		),
		'yahoo-dom-event' => array(
			'type' => 'js',
			'path' => 'yahoo-dom-event/yahoo-dom-event.js',
			'supersedes' => array('yahoo', 'event', 'dom'),
			'rollup' => 3,
			'version' => '2.5.1'
		),
		'yuiloader' => array(
			'type' => 'js',
			'path' => 'yuiloader/yuiloader-min.js',
			'supersedes' => array('yahoo', 'get'),
			'beta' => true,
			'version' => '2.5.1'
		),
		'yuiloader-dom-event' => array(
			'type' => 'js',
			'path' => 'yuiloader-dom-event/yuiloader-dom-event.js',
			'supersedes' => array('yahoo', 'dom', 'event', 'get', 'yuiloader', 'yahoo-dom-event'),
			'rollup' => 5,
			'version' => '2.5.1'
		),
		'yuitest' => array(
			'type' => 'js',
			'path' => 'yuitest/yuitest-min.js',
			'requires' => array('logger'),
			'skinnable' => true,
			'version' => '2.5.1'
		)
	);
}
